//

#ifndef ABEL_RANDOM_INTERNAL_PCG_ENGINE_H_
#define ABEL_RANDOM_INTERNAL_PCG_ENGINE_H_

#include <type_traits>
#include "abel/base/profile.h"
#include "abel/meta/type_traits.h"
#include "abel/base/int128.h"
#include "abel/random/internal/iostream_state_saver.h"
#include "abel/base/math.h"

namespace abel {

namespace random_internal {

// pcg_engine is a simplified implementation of Melissa O'Neil's PCG engine in
// C++.  PCG combines a linear congruential generator (LCG) with output state
// mixing functions to generate each random variate.  pcg_engine supports only a
// single sequence (oneseq), and does not support streams.
//
// pcg_engine is parameterized by two types:
//   Params, which provides the multiplier and increment values;
//   Mix, which mixes the state into the result.
//
template<typename Params, typename Mix>
class pcg_engine {
    static_assert(std::is_same<typename Params::state_type,
                          typename Mix::state_type>::value,
                  "Class-template abel::pcg_engine must be parameterized by "
                  "Params and Mix with identical state_type");

    static_assert(std::is_unsigned<typename Mix::result_type>::value,
                  "Class-template abel::pcg_engine must be parameterized by "
                  "an unsigned Mix::result_type");

    using params_type = Params;
    using mix_type = Mix;
    using state_type = typename Mix::state_type;

  public:
    // C++11 URBG interface:
    using result_type = typename Mix::result_type;

    static constexpr result_type (min)() {
        return (std::numeric_limits<result_type>::min)();
    }

    static constexpr result_type (max)() {
        return (std::numeric_limits<result_type>::max)();
    }

    explicit pcg_engine(uint64_t seed_value = 0) { seed(seed_value); }

    template<class SeedSequence,
            typename = typename abel::enable_if_t<
                    !std::is_same<SeedSequence, pcg_engine>::value>>
    explicit pcg_engine(SeedSequence &&seq) {
        seed(seq);
    }

    pcg_engine(const pcg_engine &) = default;

    pcg_engine &operator=(const pcg_engine &) = default;

    pcg_engine(pcg_engine &&) = default;

    pcg_engine &operator=(pcg_engine &&) = default;

    result_type operator()() {
        // Advance the LCG state, always using the new value to generate the output.
        state_ = lcg(state_);
        return Mix{}(state_);
    }

    void seed(uint64_t seed_value = 0) {
        state_type tmp = seed_value;
        state_ = lcg(tmp + Params::increment());
    }

    template<class SeedSequence>
    typename abel::enable_if_t<
            !std::is_convertible<SeedSequence, uint64_t>::value, void>
    seed(SeedSequence &&seq) {
        reseed(seq);
    }

    void discard(uint64_t count) { state_ = advance(state_, count); }

    bool operator==(const pcg_engine &other) const {
        return state_ == other.state_;
    }

    bool operator!=(const pcg_engine &other) const { return !(*this == other); }

    template<class CharT, class Traits>
    friend typename abel::enable_if_t<(sizeof(state_type) == 16),
            std::basic_ostream<CharT, Traits> &>
    operator<<(
            std::basic_ostream<CharT, Traits> &os,  // NOLINT(runtime/references)
            const pcg_engine &engine) {
        auto saver = random_internal::make_ostream_state_saver(os);
        random_internal::stream_u128_helper<state_type> helper;
        helper.write(pcg_engine::params_type::multiplier(), os);
        os << os.fill();
        helper.write(pcg_engine::params_type::increment(), os);
        os << os.fill();
        helper.write(engine.state_, os);
        return os;
    }

    template<class CharT, class Traits>
    friend typename abel::enable_if_t<(sizeof(state_type) <= 8),
            std::basic_ostream<CharT, Traits> &>
    operator<<(
            std::basic_ostream<CharT, Traits> &os,  // NOLINT(runtime/references)
            const pcg_engine &engine) {
        auto saver = random_internal::make_ostream_state_saver(os);
        os << pcg_engine::params_type::multiplier() << os.fill();
        os << pcg_engine::params_type::increment() << os.fill();
        os << engine.state_;
        return os;
    }

    template<class CharT, class Traits>
    friend typename abel::enable_if_t<(sizeof(state_type) == 16),
            std::basic_istream<CharT, Traits> &>
    operator>>(
            std::basic_istream<CharT, Traits> &is,  // NOLINT(runtime/references)
            pcg_engine &engine) {                   // NOLINT(runtime/references)
        random_internal::stream_u128_helper<state_type> helper;
        auto mult = helper.read(is);
        auto inc = helper.read(is);
        auto tmp = helper.read(is);
        if (mult != pcg_engine::params_type::multiplier() ||
            inc != pcg_engine::params_type::increment()) {
            // signal failure by setting the failbit.
            is.setstate(is.rdstate() | std::ios_base::failbit);
        }
        if (!is.fail()) {
            engine.state_ = tmp;
        }
        return is;
    }

    template<class CharT, class Traits>
    friend typename abel::enable_if_t<(sizeof(state_type) <= 8),
            std::basic_istream<CharT, Traits> &>
    operator>>(
            std::basic_istream<CharT, Traits> &is,  // NOLINT(runtime/references)
            pcg_engine &engine) {                   // NOLINT(runtime/references)
        state_type mult{}, inc{}, tmp{};
        is >> mult >> inc >> tmp;
        if (mult != pcg_engine::params_type::multiplier() ||
            inc != pcg_engine::params_type::increment()) {
            // signal failure by setting the failbit.
            is.setstate(is.rdstate() | std::ios_base::failbit);
        }
        if (!is.fail()) {
            engine.state_ = tmp;
        }
        return is;
    }

  private:
    state_type state_;

    // Returns the linear-congruential generator next state.
    static ABEL_FORCE_INLINE constexpr state_type lcg(state_type s) {
        return s * Params::multiplier() + Params::increment();
    }

    // Returns the linear-congruential arbitrary seek state.
    ABEL_FORCE_INLINE state_type advance(state_type s, uint64_t n) const {
        state_type mult = Params::multiplier();
        state_type inc = Params::increment();
        state_type m = 1;
        state_type i = 0;
        while (n > 0) {
            if (n & 1) {
                m *= mult;
                i = i * mult + inc;
            }
            inc = (mult + 1) * inc;
            mult *= mult;
            n >>= 1;
        }
        return m * s + i;
    }

    template<class SeedSequence>
    void reseed(SeedSequence &seq) {
        using sequence_result_type = typename SeedSequence::result_type;
        constexpr size_t kBufferSize =
                sizeof(state_type) / sizeof(sequence_result_type);
        sequence_result_type buffer[kBufferSize];
        seq.generate(std::begin(buffer), std::end(buffer));
        // Convert the seed output to a single state value.
        state_type tmp = buffer[0];
        for (size_t i = 1; i < kBufferSize; i++) {
            tmp <<= (sizeof(sequence_result_type) * 8);
            tmp |= buffer[i];
        }
        state_ = lcg(tmp + params_type::increment());
    }
};

// Parameterized implementation of the PCG 128-bit oneseq state.
// This provides state_type, multiplier, and increment for pcg_engine.
template<uint64_t kMultA, uint64_t kMultB, uint64_t kIncA, uint64_t kIncB>
class pcg128_params {
  public:
#if ABEL_HAVE_INTRINSIC_INT128
    using state_type = __uint128_t;

    static ABEL_FORCE_INLINE constexpr state_type make_u128(uint64_t a, uint64_t b) {
        return (static_cast<__uint128_t>(a) << 64) | b;
    }

#else
    using state_type = abel::uint128;
    static ABEL_FORCE_INLINE constexpr state_type make_u128(uint64_t a, uint64_t b) {
      return abel::make_uint128(a, b);
    }
#endif

    static ABEL_FORCE_INLINE constexpr state_type multiplier() {
        return make_u128(kMultA, kMultB);
    }

    static ABEL_FORCE_INLINE constexpr state_type increment() {
        return make_u128(kIncA, kIncB);
    }
};

// Implementation of the PCG xsl_rr_128_64 128-bit mixing function, which
// accepts an input of state_type and mixes it into an output of result_type.
struct pcg_xsl_rr_128_64 {
#if ABEL_HAVE_INTRINSIC_INT128
    using state_type = __uint128_t;
#else
    using state_type = abel::uint128;
#endif
    using result_type = uint64_t;

    ABEL_FORCE_INLINE uint64_t operator()(state_type state) {
        // This is equivalent to the xsl_rr_128_64 mixing function.
#if ABEL_HAVE_INTRINSIC_INT128
        uint64_t rotate = static_cast<uint64_t>(state >> 122u);
        state ^= state >> 64;
        uint64_t s = static_cast<uint64_t>(state);
#else
        uint64_t h = uint128_high64(state);
        uint64_t rotate = h >> 58u;
        uint64_t s = uint128_low64(state) ^ h;
#endif
        return rotr(s, rotate);
    }
};

// Parameterized implementation of the PCG 64-bit oneseq state.
// This provides state_type, multiplier, and increment for pcg_engine.
template<uint64_t kMult, uint64_t kInc>
class pcg64_params {
  public:
    using state_type = uint64_t;

    static ABEL_FORCE_INLINE constexpr state_type multiplier() { return kMult; }

    static ABEL_FORCE_INLINE constexpr state_type increment() { return kInc; }
};

// Implementation of the PCG xsh_rr_64_32 64-bit mixing function, which accepts
// an input of state_type and mixes it into an output of result_type.
struct pcg_xsh_rr_64_32 {
    using state_type = uint64_t;
    using result_type = uint32_t;

    ABEL_FORCE_INLINE uint32_t operator()(uint64_t state) {
        return rotr(
                static_cast<uint32_t>(((state >> 18) ^ state) >> 27), state >> 59);
    }
};

// Stable pcg_engine implementations:
// This is a 64-bit generator using 128-bits of state.
// The output sequence is equivalent to Melissa O'Neil's pcg64_oneseq.
using pcg64_2018_engine = pcg_engine<
        random_internal::pcg128_params<0x2360ed051fc65da4ull, 0x4385df649fccf645ull,
                0x5851f42d4c957f2d, 0x14057b7ef767814f>,
        random_internal::pcg_xsl_rr_128_64>;

// This is a 32-bit generator using 64-bits of state.
// This is equivalent to Melissa O'Neil's pcg32_oneseq.
using pcg32_2018_engine = pcg_engine<
        random_internal::pcg64_params<0x5851f42d4c957f2dull, 0x14057b7ef767814full>,
        random_internal::pcg_xsh_rr_64_32>;

}  // namespace random_internal

}  // namespace abel

#endif  // ABEL_RANDOM_INTERNAL_PCG_ENGINE_H_
